home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2000 / MacHack 2000.toast / pc / The Hacks / Doggie-Style Windows w_ Sound! / Source n' Stuff / Source / Patches.c.less old < prev    next >
Encoding:
Text File  |  2000-06-23  |  12.9 KB  |  455 lines
  1. // Source Code generated by PatchMaker 1.0
  2. // a sick idea by Paul Baxter
  3.  
  4. #if TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  5.     #error Sorry Can't do that
  6. #endif
  7.  
  8. #include <MixedMode.h>
  9. #include <Appearance.h>
  10. #include <SpeechSynthesis.h>
  11. //#include <A4Stuff.h>   // Where is this?
  12.  
  13. // This seems to replace A4Stuff.h
  14. #ifndef powerc
  15.  
  16. #define EnterCodeResource() long oldA4 = SetCurrentA4()
  17. #define ExitCodeResource() SetA4(oldA4)
  18. long SetCurrentA4(void);
  19. long SetA4(long:__D0):__D0 = 0xC18C;
  20. long GetCurrentA4(void) = 0x200C;
  21. pascal void UnloadA4Seg(void *);
  22.  
  23. #else
  24.  
  25. #define EnterCodeResource()
  26. #define ExitCodeResource()
  27. #define SetCurrentA4() 0L
  28. #define SetA4(x)    0L
  29. #define GetCurrentA4() 0L
  30. #define UnloadA4Seg(x) 0
  31.  
  32. #endif
  33.  
  34. // enums for routinedescriptor
  35. enum {
  36.     upp_DragWindowProcInfo = kPascalStackBased
  37.         |    STACK_ROUTINE_PARAMETER(1,kFourByteCode)
  38.         |    STACK_ROUTINE_PARAMETER(2,kFourByteCode)
  39.         |    STACK_ROUTINE_PARAMETER(3,kFourByteCode),
  40.     upp_NewCWindowProcInfo = kPascalStackBased
  41.         |    RESULT_SIZE(kFourByteCode)
  42.         |    STACK_ROUTINE_PARAMETER(1,kFourByteCode)
  43.         |    STACK_ROUTINE_PARAMETER(2,kFourByteCode)
  44.         |    STACK_ROUTINE_PARAMETER(3,kFourByteCode)
  45.         |    STACK_ROUTINE_PARAMETER(4,kOneByteCode)
  46.         |    STACK_ROUTINE_PARAMETER(5,kTwoByteCode)
  47.         |    STACK_ROUTINE_PARAMETER(6,kFourByteCode)
  48.         |    STACK_ROUTINE_PARAMETER(7,kOneByteCode)
  49.         |    STACK_ROUTINE_PARAMETER(8,kFourByteCode),
  50.     upp_SelectWindowProcInfo = kPascalStackBased
  51.         |    STACK_ROUTINE_PARAMETER(1,kFourByteCode),
  52.     uppPatcExtraInfo
  53. };
  54.  
  55. #define kSwell    15
  56. #define kVOffset    5
  57. #define kHOffset    6
  58.  
  59. #define Rand(min, max) (((Random() & 0x7FFF) % ((max)-(min))) + (min))
  60.  
  61. static gInMoveWindows = false;
  62.  
  63. void Swell(Rect * foo);
  64. void Initalize(void);
  65. pascal OSStatus GetWindowBounds(WindowRef window, WindowRegionCode regionCode, Rect *globalBounds);
  66. void MoveWindows(void);
  67.  
  68. SndChannelPtr theChannel;
  69.  
  70. static void Initialize(void)
  71. {
  72.     SndNewChannel(&theChannel, sampledSynth, initMono, NULL);
  73. }
  74.  
  75. pascal OSStatus GetWindowBounds(WindowRef window, 
  76.             WindowRegionCode       regionCode,Rect *globalBounds)
  77. {
  78.     OSStatus anErr = noErr;
  79. //    GrafPtr savePort;
  80.     Rect    tRect;
  81.  
  82.     (regionCode);
  83.  
  84. //    GetPort(&savePort);
  85. //    SetPort(window);
  86.  
  87.     tRect = (*((WindowPeek) window)->contRgn)->rgnBBox;
  88.  
  89.     if (nil != globalBounds)
  90.         *globalBounds = tRect;
  91.     else
  92.         anErr = paramErr;
  93.  
  94. //    SetPort(savePort);
  95.  
  96.     return anErr;
  97. }
  98.  
  99. void Swell(Rect * swellee)
  100. {
  101.     swellee->left -= kSwell;
  102.     if (swellee->left < 0)
  103.         swellee->left = 1;
  104.         
  105.     swellee->right += kSwell;
  106.     swellee->top -= kSwell/2;
  107.     if (swellee->top < 0)
  108.         swellee->top = 1;
  109.         
  110.     swellee->bottom += kSwell*2;
  111. }
  112.  
  113. void MoveWindows(void)
  114. {
  115.     WindowPeek baseWindow;
  116.     Rect    wRect = { 20,20,200,820}, mainRect;
  117.     Handle wHandle = nil, dHandle = nil;
  118.     GDHandle tGDHandle = LMGetMainDevice();
  119.     PixMapHandle tPixMapHdl = (*tGDHandle)->gdPMap;
  120.     Rect    sRect = (*tPixMapHdl)->bounds;
  121.     short d1=0;
  122.  
  123.     DebugStr("\pBefore");    
  124.     if (gInMoveWindows)
  125.         return;
  126.     DebugStr("\pAfter");    
  127.     gInMoveWindows = true;
  128.  
  129.     baseWindow = (WindowPeek) LMGetWindowList();
  130.     if (nil == baseWindow)
  131.         return;
  132.  
  133.     //wHandle = GetResource('snd ', 128);
  134.     //dHandle = GetResource('snd ', 129);
  135.  
  136.     if (wHandle)
  137.     {
  138.         HLock(wHandle);
  139.         SndPlay(theChannel, (SndListHandle) wHandle, false);
  140.         SndPlay(theChannel, (SndListHandle) wHandle, false);
  141.         HUnlock(wHandle);
  142.     }
  143.  
  144.     (void) GetWindowBounds((WindowPtr) baseWindow,kWindowGlobalPortRgn,&mainRect);
  145.     Swell(&mainRect);
  146.     
  147.     while (nil != baseWindow)
  148.     {
  149.         Point tDelta;
  150.         short direction=++d1;
  151.         Rect tRect;
  152.         baseWindow = baseWindow->nextWindow;
  153.         if (nil==baseWindow) return;
  154.         if(direction > 3) 
  155.         {
  156.             direction = 0;
  157.             d1=1;
  158.         }
  159.  
  160.         (void) GetWindowBounds((WindowPtr) baseWindow,kWindowGlobalPortRgn,&wRect);
  161.  
  162.         while(SectRect(&mainRect, &wRect, nil))
  163.         {
  164.             tDelta.h = tDelta.v = 0;
  165.             switch(direction)
  166.             {
  167.                 case 0:
  168.                 case 4:
  169.                 case 12:
  170.                     tDelta.h=kHOffset;
  171.                     break;
  172.                 case 1:
  173.                 case 5:
  174.                 case 9:
  175.                     tDelta.v=-kVOffset;
  176.                     break;
  177.                 case 2:
  178.                 case 6:
  179.                 case 10:
  180.                     tDelta.h=-kHOffset;
  181.                     break;
  182.                 case 3:
  183.                 case 7:
  184.                 case 11:
  185.                     tDelta.v=kVOffset;
  186.                     break;
  187.                 case 8:
  188.                     tDelta.v=-kVOffset;
  189.                     tDelta.h=kHOffset;
  190.                     break;
  191.             }
  192.  
  193. //                tDelta.h += Rand(-3,3);
  194. //                tDelta.v += Rand(-2,2);
  195.  
  196.             OffsetRect(&wRect,tDelta.h,tDelta.v);
  197.             MoveWindow((WindowPtr)baseWindow, wRect.left, wRect.top, false);
  198.  
  199. //                (void) GetWindowBounds((WindowPtr) baseWindow,kWindowGlobalPortRgn,&wRect);
  200.  
  201.             SectRect(&sRect, &wRect, &tRect);
  202.             if (!EqualRect(&wRect, &tRect))
  203.             {
  204.                 MoveWindow((WindowPtr)baseWindow, wRect.left - tDelta.h, wRect.top - tDelta.v, false);
  205.                 direction++;
  206.                 (void) GetWindowBounds((WindowPtr) baseWindow,kWindowGlobalPortRgn,&wRect);
  207.                 if (dHandle)
  208.                 {
  209.                     HLock(dHandle);
  210.                     SndPlay(theChannel, (SndListHandle)dHandle, true);
  211.                     HUnlock(dHandle);
  212.                 }
  213.                 
  214.             }
  215.             if (direction > 8)
  216.                 break;
  217.         }
  218.     }
  219.     gInMoveWindows = false;
  220. }
  221.  
  222. // Function Prototypes
  223. extern pascal void my_DragWindowPatch(WindowRef window, Point startPt, const Rect *boundsRect);
  224. extern pascal long my_NewCWindowPatch(void *                 wStorage,
  225.                                  const Rect *           boundsRect,
  226.                                  ConstStr255Param       title,
  227.                                  Boolean                visible,
  228.                                  short                  procID,
  229.                                  WindowRef              behind,
  230.                                  Boolean                goAwayFlag,
  231.                                  long                   refCon);
  232. extern pascal void my_SelectWindowPatch(WindowRef window);
  233.  
  234.  
  235. // Globals to hold original routine descriptors
  236. RoutineDescriptorPtr gOriginal_DragWindow = nil;
  237. RoutineDescriptorPtr gOriginal_NewCWindow = nil;
  238. RoutineDescriptorPtr gOriginal_SelectWindow = nil;
  239.  
  240.  
  241. // Tell MetroWerks the procInfo for main
  242. ProcInfoType __procinfo =  kPascalStackBased;
  243. pascal void main(void)
  244. {
  245.     RoutineDescriptorPtr originaldesc, newdesc, unImplimentedTrapAddr;
  246.     UInt32 size;
  247.     UInt16 index;
  248.     THz theZone;
  249.  
  250.     // get globals
  251.     EnterCodeResource();
  252.     // detach ourselves
  253.     DetachResource(Get1Resource('INIT', 0));
  254.  
  255.     // make sure we are in the system heap
  256.     theZone = GetZone();
  257.     SetZone(SystemZone());
  258.     
  259.     unImplimentedTrapAddr = NGetTrapAddress(_Unimplemented, (_Unimplemented & 0x0800) ? ToolTrap : OSTrap);
  260.  
  261.     originaldesc = NGetTrapAddress(_DragWindow, (_DragWindow & 0x0800) ? ToolTrap : OSTrap);
  262.     if (originaldesc != unImplimentedTrapAddr) {
  263.         if (originaldesc->goMixedModeTrap != _MixedModeMagic) {
  264.             // Trap is 68K
  265.             size = sizeof(RoutineDescriptor) + (sizeof(RoutineRecord) * 1);
  266.             // allocate new descriptor
  267.             newdesc = (RoutineDescriptorPtr) NewPtrSys(size);
  268.             if (!newdesc) {
  269.                 Debugger();
  270.                 return;
  271.             }
  272.             // set fields of routine decscriptor
  273.             newdesc->goMixedModeTrap = _MixedModeMagic;
  274.             newdesc->version = 7;
  275.             newdesc->routineDescriptorFlags = 0;
  276.             newdesc->reserved1 = 0;
  277.             newdesc->reserved2 = 0;
  278.             newdesc->selectorInfo = 0;
  279.             newdesc->routineCount = 0;
  280.             index = 0;
  281.             gOriginal_DragWindow = originaldesc;
  282.             newdesc->routineRecords[index].procInfo = upp_DragWindowProcInfo;
  283.             newdesc->routineRecords[index].reserved1 = 0;
  284.             newdesc->routineRecords[index].ISA = GetCurrentArchitecture();
  285.             newdesc->routineRecords[index].routineFlags = 4;
  286.             newdesc->routineRecords[index].procDescriptor = (ProcPtr)my_DragWindowPatch;
  287.             newdesc->routineRecords[index].reserved2 = 0;
  288.             newdesc->routineRecords[index].selector = 0;
  289.         }
  290.         else {
  291.             // Trap is CFM
  292.             size = sizeof(RoutineDescriptor) + (sizeof(RoutineRecord) * originaldesc->routineCount);
  293.             newdesc = (RoutineDescriptorPtr) NewPtrSys(size);
  294.             if (!newdesc) {
  295.                 DebugStr("\pFailed to allocate RoutineDescriptor");
  296.                 return;
  297.             }
  298.             BlockMoveData(originaldesc, newdesc, size);
  299.             gOriginal_DragWindow = originaldesc;
  300.             index = 0;
  301.             newdesc->routineRecords[index].procDescriptor = (ProcPtr)my_DragWindowPatch;
  302.             newdesc->routineRecords[index].ISA = GetCurrentArchitecture();
  303.         }
  304.         NSetTrapAddress((UniversalProcPtr) newdesc, _DragWindow, (_DragWindow & 0x0800) ? ToolTrap : OSTrap);
  305.     }
  306.  
  307.     originaldesc = NGetTrapAddress(_NewCWindow, (_NewCWindow & 0x0800) ? ToolTrap : OSTrap);
  308.     if (originaldesc != unImplimentedTrapAddr) {
  309.         if (originaldesc->goMixedModeTrap != _MixedModeMagic) {
  310.             // Trap is 68K
  311.             size = sizeof(RoutineDescriptor) + (sizeof(RoutineRecord) * 1);
  312.             // allocate new descriptor
  313.             newdesc = (RoutineDescriptorPtr) NewPtrSys(size);
  314.             if (!newdesc) {
  315.                 Debugger();
  316.                 return;
  317.             }
  318.             // set fields of routine decscriptor
  319.             newdesc->goMixedModeTrap = _MixedModeMagic;
  320.             newdesc->version = 7;
  321.             newdesc->routineDescriptorFlags = 0;
  322.             newdesc->reserved1 = 0;
  323.             newdesc->reserved2 = 0;
  324.             newdesc->selectorInfo = 0;
  325.             newdesc->routineCount = 0;
  326.             index = 0;
  327.             gOriginal_NewCWindow = originaldesc;
  328.             newdesc->routineRecords[index].procInfo = upp_NewCWindowProcInfo;
  329.             newdesc->routineRecords[index].reserved1 = 0;
  330.             newdesc->routineRecords[index].ISA = GetCurrentArchitecture();
  331.             newdesc->routineRecords[index].routineFlags = 4;
  332.             newdesc->routineRecords[index].procDescriptor = (ProcPtr)my_NewCWindowPatch;
  333.             newdesc->routineRecords[index].reserved2 = 0;
  334.             newdesc->routineRecords[index].selector = 0;
  335.         }
  336.         else {
  337.             // Trap is CFM
  338.             size = sizeof(RoutineDescriptor) + (sizeof(RoutineRecord) * originaldesc->routineCount);
  339.             newdesc = (RoutineDescriptorPtr) NewPtrSys(size);
  340.             if (!newdesc) {
  341.                 DebugStr("\pFailed to allocate RoutineDescriptor");
  342.                 return;
  343.             }
  344.             BlockMoveData(originaldesc, newdesc, size);
  345.             gOriginal_NewCWindow = originaldesc;
  346.             index = 0;
  347.             newdesc->routineRecords[index].procDescriptor = (ProcPtr)my_NewCWindowPatch;
  348.             newdesc->routineRecords[index].ISA = GetCurrentArchitecture();
  349.         }
  350.         NSetTrapAddress((UniversalProcPtr) newdesc, _NewCWindow, (_NewCWindow & 0x0800) ? ToolTrap : OSTrap);
  351.     }
  352.  
  353.     originaldesc = NGetTrapAddress(_SelectWindow, (_SelectWindow & 0x0800) ? ToolTrap : OSTrap);
  354.     if (originaldesc != unImplimentedTrapAddr) {
  355.         if (originaldesc->goMixedModeTrap != _MixedModeMagic) {
  356.             // Trap is 68K
  357.             size = sizeof(RoutineDescriptor) + (sizeof(RoutineRecord) * 1);
  358.             // allocate new descriptor
  359.             newdesc = (RoutineDescriptorPtr) NewPtrSys(size);
  360.             if (!newdesc) {
  361.                 Debugger();
  362.                 return;
  363.             }
  364.             // set fields of routine decscriptor
  365.             newdesc->goMixedModeTrap = _MixedModeMagic;
  366.             newdesc->version = 7;
  367.             newdesc->routineDescriptorFlags = 0;
  368.             newdesc->reserved1 = 0;
  369.             newdesc->reserved2 = 0;
  370.             newdesc->selectorInfo = 0;
  371.             newdesc->routineCount = 0;
  372.             index = 0;
  373.             gOriginal_SelectWindow = originaldesc;
  374.             newdesc->routineRecords[index].procInfo = upp_SelectWindowProcInfo;
  375.             newdesc->routineRecords[index].reserved1 = 0;
  376.             newdesc->routineRecords[index].ISA = GetCurrentArchitecture();
  377.             newdesc->routineRecords[index].routineFlags = 4;
  378.             newdesc->routineRecords[index].procDescriptor = (ProcPtr)my_SelectWindowPatch;
  379.             newdesc->routineRecords[index].reserved2 = 0;
  380.             newdesc->routineRecords[index].selector = 0;
  381.         }
  382.         else {
  383.             // Trap is CFM
  384.             size = sizeof(RoutineDescriptor) + (sizeof(RoutineRecord) * originaldesc->routineCount);
  385.             newdesc = (RoutineDescriptorPtr) NewPtrSys(size);
  386.             if (!newdesc) {
  387.                 DebugStr("\pFailed to allocate RoutineDescriptor");
  388.                 return;
  389.             }
  390.             BlockMoveData(originaldesc, newdesc, size);
  391.             gOriginal_SelectWindow = originaldesc;
  392.             index = 0;
  393.             newdesc->routineRecords[index].procDescriptor = (ProcPtr)my_SelectWindowPatch;
  394.             newdesc->routineRecords[index].ISA = GetCurrentArchitecture();
  395.         }
  396.         NSetTrapAddress((UniversalProcPtr) newdesc, _SelectWindow, (_SelectWindow & 0x0800) ? ToolTrap : OSTrap);
  397.     }
  398.  
  399.     // restore to original heap
  400.     SetZone(theZone);
  401.     // restore globals
  402.     ExitCodeResource();
  403. }
  404.  
  405.  
  406. pascal void my_DragWindowPatch(WindowRef window, Point startPt, const Rect *boundsRect)
  407. {
  408.     // Get globals
  409.     EnterCodeResource();
  410.  
  411.     CALL_THREE_PARAMETER_UPP( gOriginal_DragWindow, upp_DragWindowProcInfo, window, startPt, boundsRect);
  412.  
  413.     MoveWindows();
  414.     gInMoveWindows = false;
  415.     // Release globals
  416.     ExitCodeResource();
  417. }
  418.  
  419. pascal long my_NewCWindowPatch(void *                 wStorage,
  420.                                  const Rect *           boundsRect,
  421.                                  ConstStr255Param       title,
  422.                                  Boolean                visible,
  423.                                  short                  procID,
  424.                                  WindowRef              behind,
  425.                                  Boolean                goAwayFlag,
  426.                                  long                   refCon)
  427. {
  428.     long result;
  429.     // Get globals
  430.     EnterCodeResource();
  431.  
  432.     result = CALL_EIGHT_PARAMETER_UPP( gOriginal_NewCWindow, upp_NewCWindowProcInfo,
  433.         wStorage,boundsRect,title,visible,procID,behind,goAwayFlag,refCon);
  434.     MoveWindows();
  435.     gInMoveWindows = false;
  436.     // Release globals
  437.     ExitCodeResource();
  438.     return result;
  439. }
  440.  
  441. pascal void my_SelectWindowPatch(WindowRef window)
  442. {
  443.     // Get globals
  444.     EnterCodeResource();
  445.  
  446. //    DebugStr("\p|my_SelectWindowPatch-I-Debug;");
  447.  
  448.     CALL_ONE_PARAMETER_UPP( gOriginal_SelectWindow, upp_SelectWindowProcInfo, window);
  449.     MoveWindows();
  450.     gInMoveWindows = false;
  451.     // Release globals
  452.     ExitCodeResource();
  453. }
  454.  
  455.